Accelerator engine for processing functions used in audio algorithms

ABSTRACT

An engine for processing functions used in audio algorithms. The engine runs in parallel with a digital signal processor (DSP) in an audio chip to increase performance for that chip. Functions performed by the engine include biquad filtering and inverse discrete cosine transform (IDCT) including pre-multiplication, inverse Fast Fourier transform (IFFT), and post-multiplication, which would otherwise be performed by the DSP. The DSP is therefore free to perform other functions demanded by the chip. Resources in the engine are processed in a pipeline structure and are thus highly utilized. Data are stored in a predefined order to increase efficiency.

BACKGROUND OF THE INVENTION

1. Technical Field

This invention relates generally to audio digital signal processing (DSP) and more particularly to processing functions used in audio algorithms.

2. Discussion of Background Art

An Inverse Discrete Cosine Transformation (IDCT), which transforms data from the frequency domain to the time domain, requires a pre-multiplication, an inverse Fast Fourier Transformation (IFFT), and a post-multiplication. IDCT is used as one of the last stages of the Dolby®'s third generation audio coding (AC3) decompressing process.

Performing a 128-point IFFT requires 64*7 (=448) radix 2 butterflies, each defined by A′=A−BC and B′=A+BC, where A, A′, B, B′ and C are complex numbers in the form of D=d_(r)+jd_(i). A subscript r denotes the real part, and a subscript i denotes the imaginary part of the complex number.

FIG. 1 shows an audio integrated circuit chip 100 that includes a DSP 102, a Random Access Memory (RAM) 106, a Read Only Memory (ROM) 110, and an Input/Output (I/O) interface 114. DSP 102 provides the main digital signal processing for chip 100 including, for example, filtering and transforming audio samples. RAM 106 is a “memory on chip” used by programs running on DSP 102 to store data relating to input audio samples and the processing performed on those samples. ROM 110 stores additional data for DSP 102. I/O interface 114 implements various protocols for exchanging, via databus 4005, audio samples with external devices such as analog-to-digital (A/D) and digital-to-analog (D/A) converters, etc.

As audio AC3 and surround sound features are added to chip 100, DSP 102 cannot perform as fast as desired, that is, it cannot execute as many million instructions per second (MIPs) as are required to do all of the tasks demanded by chip 100, including, for example, receiving AC3 data, detecting AC3 data error, using IDCT to decode data, and performing audio enhancement and 3D features. One approach to improving DSP 102 performance, or to conserving DSP 102 MIPs for other desired functions, accelerates the AC3 decompressing stage. However, this approach requires operations that are tightly coupled with the AC3 algorithm, which in turn requires that a designer be intimately familiar with the AC3 decoding process. Further, the approach is useful for accelerating AC3, but provides no benefits for other audio functions or Moving Picture Expert Group (MPEG) functions.

Therefore, what is needed is a mechanism to efficiently improve performance of DSP 102, and thereby performance of chip 100.

SUMMARY OF THE INVENTION

The present invention provides an accelerator engine running in parallel with a DSP in an audio chip to improve its performance. The engine avoids AC3-specific algorithms and focuses on general purpose DSP functions, including biquad filtering and IDCT, that comprise pre-multiplication, IFFT, and post-multiplication. The DSP is therefore free to do other processing while the engine is performing a requested function. The engine utilizes its resources in a pipeline structure for increased efficiency. In the biquad and double precision biquad modes the engine stores data in predefined locations in memory to efficiently access the data. The engine also uses an equation and data values stored in the predefined locations to calculate an audio sample. The calculated result is then stored in a memory location in a way that it can easily be used to calculate the next sample. In a preferred embodiment the engine efficiently saves 15 MIPs in an AC3 based 3D audio product, including 7.5 MIPs in the AC3 decoding process by accelerating the IFFT, and 7.5 MIPs from the 3D processing via a biquad filtering function.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a prior art DSP chip;

FIG. 2 shows a chip utilizing the accelerator engine according to the invention;

FIG. 3 is a block diagram of the accelerator engine;

FIG. 4A shows a pipeline structure for the pre-multiplication mode;

FIG. 4B shows a resource utilization map for the pre-multiplication mode;

FIG. 5A shows a pipeline structure for the FFT mode;

FIG. 5B shows a resource utilization map for the FFT mode;

FIG. 5C shows C code describing the address generation for both 128-point and 64-point FFTs;

FIG. 6A shows a pipeline structure for the biquad filtering mode;

FIG. 6B shows a resource utilization map for the biquad filtering mode;

FIG. 6C is a flowchart illustrating how the accelerator engine processes the biquad filtering;

FIG. 6D is a flowchart illustrating how the accelerator engine stores data during the biquad filtering mode;

FIG. 6E illustrates data in memory during a biquad filtering mode;

FIG. 7A shows a pipeline structure for the double precision biquad filtering mode;

FIG. 7B shows a resource utilization map for the double precision biquad filtering mode:

FIG. 7C illustrates data in memory during a double precision biquad filtering mode; and

FIG. 8 is a flowchart illustrating how a chip requests that a function be performed by the accelerator engine.

DETAIL DESCRIPTION OF THE PREFERRED EMBODIMENT

The present invention provides an accelerator engine running in parallel with a DSP for processing functions that are usable by audio algorithms including, for example, AC3, 3D, bass managements, MP3, etc., and that would otherwise be performed by the DSP. Consequently, the DSP is free to process other tasks.

FIG. 2 shows a chip 250 utilizing the invention. Integrated circuit chip 250 is like chip 100 except that chip 250 includes an accelerator engine 200 interfacing via data bus 2003 with DSP 102. Data passing through databus 2003 includes configuration information and data for accelerator engine 200 to perform a requested function.

FIG. 3 is a block diagram of accelerator engine 200 preferably including an RRAM 304, an IRAM 308, a ROM 312, a control register 316, a state machine 320, a multiplier (MPY) 326, a shift/sign extender 328, an ALU 330, and other components. In the preferred embodiment accelerator engine 200 supports the following functions: single biquad filtering; double precision biquad filtering; radix2, 7 passes, 128-point IFFT; radix2, 6 passes, 64-point IFFT, premultiplication 128-word and 64-word configurations, post-multiplication 128-word and 64-word configurations. IDCT 128-word and 64-word configurations, and BFE-RAM read/write.

RRAM 304, depending on the required function, stores different types of values. For example, for a biquad filtering function, RRAM 304 stores filter coefficients. For IFFT and IDCT functions, RRAM 304 stores real parts and IRAM 308 stores imaginary parts of complex numbers required by these functions. Data in RRAM 304 and IRAM 308, where appropriate, contains new values after each time accelerator engine 200 has calculated an audio sample.

ROM 312 is used in IFFT and IDCT modes preferably to store both real and imaginary values for complex numbers required by IFFT and IDCT functions.

State machine 320 generates addresses for RRAM 304, IRAM 308, and ROM 312 and control signals for other circuitry of accelerator engine 200.

MPY 326 is preferably a conventional 24-bit multiplier for multiplying data on lines 3031 and 3035.

Shifter/Sign-Extender 328 shifts its contents to adjust or mask a sign bit on lines 3041 and 3045.

ALU 330 is preferably a conventional ALU which accumules, adds, or subtracts data on lines 3051 and 3055. ALU 330 can be divided into an ALUA (not shown) and an ALUB (not shown) for use when two ALUs are required, such as in the pre-multiplication, IFFT, and post-multiplication modes.

Multiplexers (MUXes) M01, M03, M05, M07, M09, M11, and M13 perform conventional functions of MUXes, that is, passing selected inputs based on select signals (not shown) provided by state machine 320 and appropriate circuitry.

Latches L01, L03, L05, L07, L08, L09, L11, L13, L15, and L17 perform conventional functions of latches including passing inputs based on clocking signals (not shown) provided by state machine 320 and appropriate circuitry.

This specification uses the following notations in several tables for a pipeline structure and for a resource utilization map. Each column represents a critical resource (RRAM 304, IRAM 308, MPY 326, etc.). Each row represents a phase-one-to-phase-one clock cycle, which lasts 20 ns in a preferred embodiment. The tables show what each resource is doing during each cycle. In a resource utilization map, the number in each entry represents the number of operations a resource is executing during a given cycle. A “0” indicates a resource is idle; a “1” indicates a resource is busy.

In the preferred embodiment the pre- and post-multiplication modes pass data and multiply each data item by a unique complex constant preferably stored in ROM 312, that is, A _(n) =A _(n) C _(n) where A _(n) =a _(m) +ja _(in) and C _(n) =c _(m) +jc _(in). Parameters a_(m) and a_(in) represent data in RRAM 304 and IRAM 308, respectively, and C_(n) are filter coefficients in ROM 312. In the preferred embodiment, n ranges from 0 to 127 (for 128 data points). The pre- and post-multiplication modes are identical except that data is accessed linearly in the pre-multiplication mode and in bit-reverse order in the post-multiplication mode because the IFFT mode leaves its results in bit-reverse order. Coefficients are accessed linearly in both the pre- and the post-multiplication modes.

FIG. 4A shows a pipeline structure for the pre-multiplication mode. In cycle 1 accelerator engine 200 reads b_(r) from RRAM 304, b_(i) from IRAM 308, and c_(r) from ROM 312. In cycle 2 accelerator engine 200 reads c_(i) from ROM 312. In cycles 3 through 6 MPY 326 performs b_(r)*c_(r), b_(i)*c_(i), b_(r)*c_(i), and b_(i)*c_(r), respectively. Accelerator engine 200, instead of using the same c_(r) and c_(i) that were read from ROM 312 in cycles 1 and 2, rereads c_(i) and c_(r) from ROM 312 in cycles 3 and 4. Rereading these values in cycles 3 and 4 avoids using a register to store the values read in cycles 1 and 2. Further, ROM 312 is available for accessing its data in cycles 3 and 4. ALUA in cycles 6 and 7 performs A=b_(r)*c_(r)+0 and A₀=A−(b_(i)*c_(i)), respectively. ALUB in cycles 8 and 9 performs B=b_(r)*c_(i) and B₀=B+(b_(i)*c_(i)), respectively. In cycle 10 accelerator engine 200 writes b_(r) and b_(i) into RRAM 304 and IRAM 308, respectively. In this pipeline structure, data required for a function in each cycle is made available before the data is needed. For example, b_(r) and c_(r) used by MPY 326 in cycle 3 have been made ready to MPY 326 by reading RRAM 304 and IRAM 308 in cycle 1.

FIG. 4B shows a resource utilization map for the pre-multiplication mode, which, starting on any four cycle boundary and taking four cycles, shows the number of operations a resource is executing. For example, MPY 326 and ROM 312 perform four operations (all four 1's), one in each of the four selected cycles 1 to 4. ALUA performs two operations (one in each of cycles 2 and 3) while ALUB performs two operations (one in each of cycles 1 and 4). Data is accessed in cycles 1 and 2 for RRAM 304 and IRAM 308. Therefore, MPY 326 and ROM 312 are utilized 100% of the time (4 operations in tour cycles) while each of ALUA, ALUB, RRAM 304, and IRAM 308 is utilized 50% of the time (2 operations in 4 cycles).

Accelerator engine 200 preferably uses seven passes of a radix 2 butterfly to process IFFTs, and employs the following equations: A′=A−BC and B′=A+BC, where A, A′, B, B′, and C are complex numbers.

FIG. 5A shows a pipeline structure for the IFFT mode and FIG. 5B shows a resource utilization map for the IFFT mode. The explanations of this IFFT pipeline structure and resource utilization map are similar to the respective explanations of the pre-multiplication mode in FIGS. 4A and 4B. For example, in cycle 1 accelerator engine 200 reads b_(r) and c_(r) from RRAM 304 and ROM 312 respectively; MPY 326 is utilized 100% of the time because in the selected four cycles MPY 326 performs four operations; etc. Consequently, as shown in FIG. 5B, all resources are utilized 100% of the time.

Accelerator engine 200 performs each pass of the IFFT mode sequentially in both 128-point IFFT and 64-point IFFT. The difference between each pass is the method by which data points are addressed. The addressing schemes for the two modes are similar. FIG. 5C lists C-code describing the address generation for both 128-point FFT and 64-point FFT modes.

In the biquad filtering mode, accelerator engine 200 uses the equation: y _(n) =b ₀ x _(n) +b ₁ x _(n−1) +b ₂ x _(n−2) +a ₁ y _(n−1) +a ₂ y _(n−2)  (1) where the subscript n indicates the current sample number; x_(n) is the current input sample and y_(n) is the current output sample; and b₀, b₁, b₂, a₁, and a₂ are filter coefficients.

Accelerator engine 200 stores filter coefficients in RRAM 304 and input samples and filter states in IRAM 308. In the biquad filtering mode, 48-bit ALU 330 remains as one ALU (instead of being divided into two ALUs: ALUA and ALUB).

FIG. 6A shows a pipeline structure for the biquad filtering mode.

FIG. 6B shows a resource utilization map for the biquad filtering mode. This pipeline structure can be repeated every six cycles and all resources will be used five out of every six cycles.

FIG. 6C is a flowchart illustrating a method for accelerator engine 200 to perform a biquad filtering in accordance with the invention. In step 604, accelerator engine 200 receives, for example, 124 sample data points represented by x₀ to x₁₂₃. In step 608, accelerator engine 200 stores data in IRAM 308. In step 612, accelerator engine 200 uses equation (1) to calculate y_(n) for n=0 to n=123, that is, y₀ to y₁₂₃, and store them in appropriate locations in IRAM 308. Accelerator engine 200 then continues to receive, store, and calculate sampled data in respective steps 604, 608, and 612 until all data has been received. Then accelerator engine 200 completes the biquad filtering function in step 620.

FIG. 6D is a flowchart illustrating how accelerator engine 200, in accordance with steps 608 and 612 of FIG. 6C, calculates and stores y_(n) in IRAM 308 locations for 124 samples of x_(n) from x₀ to x₁₂₃. In step 604D accelerator engine 200 stores x₀ to x₁₂₃ in locations 4 to location 127. Accelerator engine 200 also stores values of y⁻², y⁻¹, x⁻², and x⁻¹ in locations 0, 1, 2, and 3, respectively. In this FIG. 6D, locations 0 to 127 are used for illustrative purpose only, any 128 locations, for example, 1 to 128, 2 to 129, or K to K+128−1 are applicable. In step 608D accelerator engine 200 uses the values in locations 0, 1, 2, 3, and 4 to calculate y₀. In step 612D accelerator engine 200 stores the value of y₀ in location 2. Accelerator engine 200 then returns to step 608D to calculate y₁ and store y₁ in location 3, which is one location higher than location 2 storing y₀. Accelerator engine 200 keeps calculating and storing values of y until accelerator engine 200 is done, that is, accelerator engine 200 calculates and stores values of y₂ to y₁₂₃ in location 4 through location 125, respectively. Accelerator engine 200, in calculating y₀ to y₁₂₃, uses values of a₂, a₁, b₂, b₁, and b₀ preferably stored in ROM 312. Those skilled in the art will recognize that calculating y₀ (n=0), based on equation (1), requires y⁻², y⁻¹, x⁻², x⁻¹, and x₀. The invention uses the zero value for each of y⁻², y⁻¹, x⁻², and x⁻¹, to calculate the first sequence of 124 x_(n) samples.

FIG. 6E illustrates how IRAM 308 stores a data value for each y_(n) from y₀ to y₁₂₃. The “Address” column shows locations from 0 to 127 in IRAM 308. The “Initial Data” column shows data of y⁻², y⁻¹, x⁻², x⁻¹, and x₀ to x₁₂₃ in corresponding locations of the “Address” column. Columns n=0, n=1, n=2, n=3, . . . to n=123, show data in IRAM 308 locations for y_(n) for n=0 to n=123, respectively. Box 655 includes values (of y⁻², y⁻¹, x⁻², x⁻¹, and x₀) that are used to calculate y₀. Similarly, boxes 659, 663, and 669 include values (y⁻¹, y₀, x⁻¹, etc.) that are used to calculate y₁, y₂, and y₃, respectively. According to the invention, IRAM 308 locations of values in boxes 655, 659, 663 and 669, etc., are increased by one for each increment of n. For example, box 655 includes values in locations 0 through 4, box 659 includes values in locations 1 through 5, box 663 includes values in locations 2 through 6, and box 669 includes values in locations 3 through 7, etc. Arrow 602 indicates that y₁ is stored in location three, which is one location higher than the location of y₀. Similarly, arrow 604 indicates that y₂ is stored in location four, one location higher than the location of y₁. Column n=123 shows that y₀ to y₁₂₃ are stored in locations 2 to 125, respectively. Consequently, the invention, while writing the result of y_(n) (e.g., y₀ in column n=0) over the oldest x value (e.g., x⁻² in the “Initial Data” column) permits the data for calculating y_(n+1) (e.g., y₁) to appear perfectly ordered in the subsequent five locations (e.g., location 1 through location 5). In accordance with the invention, calculating and storing y_(n) for subsequent sequences of 124 samples of x, that is, calculating and storing y_(n) for n=124 to n=247, for n=248 to n=371, and for n=372 to n=495, etc., is similar to calculating and storing y_(n) for n=0 to n=123. The invention thus uses the same IRAM 308 locations from location 0 to location 127 for calculating and storing y_(n) for subsequent sequences of 124 samples of x. As discussed above, the invention uses the zero value for y⁻, y⁻¹, x⁻², and x⁻¹ for the first sequence of 124 samples of x. For a second sequence of 124 samples of x the invention uses y₁₂₂, y₁₂₃, x₁₂₂, and x₁₂₃ for y⁻², y⁻¹, x⁻², and x⁻¹, respectively. Similarly, for a third sequence of 124 samples of x the invention uses y₂₄₆, y₂₄₇, x₂₄₆, and x₂₄₇ for y⁻², y⁻¹, x⁻² and x⁻¹, respectively. In calculating y_(n) accelerator engine 200 stores filter coefficients preferably in RRAM 304 in order of a₂, a₁, b₂, b₁, and b₀.

The double precision biquad mode is similar to the (single) biquad mode, but the feedback state is stored and calculated as double precision for greater numerical stability. The equation for the double precision biquad mode is y _(n) =b ₀ x _(n) +b ₁ x _(n−1) +b ₂ x _(n−2) +a ₁ yl _(n−1) +a ₂ yl _(n−2)   (2) in which yl_(n) represents the lower half bits and yh_(n) represents the upper half bits of y_(n). In the preferred embodiment, a double precision term y_(n) comprises 48 bits, and therefore each term y_(ln) and yh_(n) comprises 24 bits.

FIG. 7A shows a pipeline structure for the double precision biquad mode.

FIG. 7B shows a resource utilization map for the double precision biquad mode. In this mode accelerator engine 200 operates in a pipeline fashion that repeats every nine cycles.

The method for calculating y_(n) in the double precision mode is similar to that for calculating in the biquad mode except, instead of five values (x_(n), x_(n−1), x_(n−2), y_(n−1), and y_(n−2)) accelerator engine 200 uses seven values (x_(n), x_(n−1), x⁻², yl_(n−1), yl_(n−2), yh_(n−1), and yh_(n−2)) as required by equation (2), to calculate each y_(n). Further, after calculating y₀, the invention stores yh₀ and yl₀ in respective locations 2 and 4. Similarly, after calculating y₁, the invention stores yh₁ and yl₁ in respective locations 3 and 5, each location being one higher than the respective locations of yh₀ and yl₀. Thus for each y_(n), the invention stores yh_(n) and yin each in one location higher than the locations of respective yh_(n−1) and yl_(n−1).

FIG. 7C shows how accelerator engine 200 stores calculating and calculated values in IRAM 308 for the double precision biquad mode. The “Address” column shows locations from 0 to 127 in IRAM 308. The “Initial Data” column shows data of yh⁻², yh⁻¹, yl⁻², yl⁻¹, x⁻², x⁻¹, and x₀ to x₁₂₁ in corresponding locations of the “Address” column. Columns 0, 1, 2, 3, . . . to 121 show data in IRAM 308 locations for x_(n) and y_(n) for n=0 to n=121, respectively. Box 755 includes values (of yh⁻², yh⁻¹, yl⁻², yl⁻¹, x⁻², x⁻¹, and x₀) that are used to calculate y₀. Similarly, boxes 759, 763, and 769 include values (yh⁻¹, yh₀, yl⁻¹, yl₀, x⁻¹, etc.) that are used to calculate y₁, y₂, and y₃, respectively. According to the invention, IRAM 308 locations of values in boxes 759, 763, 769, etc., are increased by one for each increment of n. For example, box 755 includes values in locations 0 through 6, box 759 includes values in locations 1 through 7, box 763 includes values in locations 2 through 8, and box 769 includes values in locations 3 through 9, etc. Arrow 702 indicates that yh₁ is stored in location 3, which is one location higher than the location of yh₀. Arrow 703 indicates that yl₁ is stored in location 5, which is one location higher than the location of yl₀. Similarly, arrows 704 and 705 indicate that yh₂ and yl₂ are each stored in locations one higher than the respective locations of yh₁ and yl₁, etc. Column n=121 shows that yh₀ to yh₁₂₁ are stored in respective locations 2 to 123, while yl₁₂₀ and yl₁₂₁ are stored in respective locations 124 and 125, and x₁₂₀ and x₁₂₁ are stored in respective locations 126 and 127. Consequently, the invention while writing the result of yh_(n) and yl_(n) (e.g., yh₀ and yl₀ in column n=0) over the oldest values of yl and x (e.g., yl⁻² and x⁻² in the “Initial Data” column) permits the data for calculating y_(n+1) (e.g., y₁) to appear perfectly ordered in the subsequent seven locations (e.g., location one through location seven). As in the biquad filtering mode, calculating and storing y_(n) for subsequent sequences of 122 samples of x, that is, calculating and storing y_(n) for n=122 to n=243, for n=244 to n=365, and for n=366 to n=487, etc., is similar to calculating and storing y_(n) for n=0 to n=122. The invention thus uses the same IRAM 308 locations from location 0 to location 127 for calculating and storing y_(n) for subsequent sequences of 122 samples of x. As discussed above, the invention uses the zero value for yh⁻², yh⁻¹, yl⁻², yl⁻¹, x⁻², and x⁻¹ for the first sequence of 122 samples of x. For a second sequence of 122 samples of x the invention uses yh₁₂₀, yh₁₂₁, yl₁₂₀, yl₁₂₁, x₁₂₀, and x₁₂₁ for yh⁻², yh⁻¹, yl⁻², yl⁻¹, x⁻², and x⁻¹, respectively. Similarly, for a third sequence of 122 samples of x the invention uses yh₂₄₂, yh₂₄₃, yl₂₄₂, yl₂₄₃, x₂₄₂, and x₂₄₃ for yh⁻², yh⁻¹, yl_(—2), yl⁻¹, x⁻², and x⁻¹, respectively. In calculating y_(n), accelerator engine 200 stores filter coefficients preferably in RRAM 304 in order of a₂, a₁, a₂, a₁, b₂, b₁, b₀.

FIG. 8 is a flowchart illustrating how chip 100 invokes a function performed by accelerator engine 200. In step 804 chip 100 writes to configuration register 316 to set the required mode and halt accelerator engine 200. In step 808 chip 100 downloads required data from chip 100 to accelerator engine 200. For the pre-multiplication. IFFT, or post-multiplication modes chip 100 downloads data preferably in the order of 0 to 127 and alternating between RRAM 304 and IRAM 308. For the biquad mode, chip 100 downloads coefficients preferably in the order of a₂, a₁, b₂, b₁, and b₀ in RRAM 304. Similarly, for the double precision biquad mode, chip 100 downloads coefficients preferably in the order of a₂, a₁, a₂, a₁, b₂, b₁, and b₀. Chip 100 also downloads data in the order from 0 to 127, which is the order shown in the “Initial Data” column in FIG. 6E. In step 812 chip 100 determines whether all of the data has been downloaded. If the data is not completely downloaded then chip 100 in step 808 keeps downloading data, but if data is completely downloaded then chip 100 in step 816 sets the run bit in configuration register 316 so that accelerator engine 200 in step 820 can perform the requested function. Chip 100 in step 824 monitors the status of the done bit in configuration register 316 to determine whether accelerator engine 200 has completed its requested task. In step 828 accelerator engine 200 completes its requested task, and, depending on the mode, chip 100 may or may not set the done bit in configuration register 316. For example, if the requested task is a stand-alone pre-multiplication, then chip 100 sets the done bit, but if the task is an IDCT function then chip 100 does not set the done bit because accelerator engine 200 would continue to perform the IFFT function after completing the pre-multiplication function. In step 832 chip 100, via bus 2003 (FIG. 2), reads data from accelerator engine 200 in linear order except in the IFFT mode where IFFT functions leave data in bit-reverse order.

The invention has been explained above with reference to a preferred embodiment. Other embodiments will be apparent to those skilled in the art after reading this disclosure. Therefore, these and other variations upon the preferred embodiment are intended to be covered by the appended claims. 

1. A method for improving performance of an audio chip including a DSP comprising: providing an apparatus having a plurality of elements running in parallel with the DSP; configuring the apparatus to perform a function according to a configuration setup; and employing the apparatus for accessing data from the plurality of elements in a pipeline structure to maximize utilization of the plurality of elements, wherein data is accessed in a four-cycle pipeline structure in a pre-multiplication function, in an IFFT function, and in a post-multiplication function; wherein data is accessed in a six-cycle pipeline structure in a biquad mode; and wherein data is accessed in a nine-cycle pipeline structure in a double precision biquad mode. 